Java基础11：线程；synchronized；延迟加载（懒汉模式）；死锁

最新推荐文章于 2023-08-18 15:46:24 发布

若云_bai

最新推荐文章于 2023-08-18 15:46:24 发布

阅读量1k

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/zxloveooo/article/details/10470547

版权

java基础专栏收录该内容

39 篇文章 0 订阅

订阅专栏

关键字：Thread；Runnable；synchronized；延迟加载（懒汉模式）；死锁

一、多线程概述

1、进程：是一个正在执行中的程序。
(1)、每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
2、线程：就是进程中的一个独立的控制单元
(1)、线程控制着进程的执行。
(2)、一个进程中，至少有一个线程
3、Java VM 启动的时候会有一个进程 java.exe
(1)、该进程中至少有一个线程负责 java 程序的执行
(2)、而且这个线程运行的代码存在于 main 方法中
(3)、该线程称为主线程
4、扩展：其实更细节说明 jvm ，jvm 启动不止一个线程，还有负责垃圾回收机制的线程
二、创建线程-继承Thread类
1、一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
(1)、定义类继承 Thread
(2)、复写 Thread 类中的 run 方法
[1]、目的：将自定义代码存储在 run 方法周中，让线程运行
(3)、调用线程的 start 方法，该方法有两个作用：启用线程，调用 run 方法
(4)、发现运行结果每次都不同，因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行
(5)、明确一点，在某一时刻，只能有一个程序在运行，(多核除外)
(6)、cpu在做着快速的切换，一道道看上去是同时运行的效果，
(7)、我们可以形象吧多线程运行行为在互相抢夺，cpu 执行权
(8)、这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，cpu说的算

2、例子

class ThreadDemo extends Thread{
    // PrimeRun(long minPrime) {
        // this.minPrime = minPrime;
    // }
    public void run(){
        for(int x=0;x<60;x++){
            System.out.println("ThreadDemo ru："+x);
        }
    }
}
public class Demo{
    public static void main(String[] args){
        ThreadDemo d = new ThreadDemo();
        d.start();
        for(int x=0;x<60;x++){
            System.out.println("Demo run："+x);
        }
    }
}

三、创建线程-run和start特点

1、为什么要覆盖 run 方法呢，thread 类用于描述线程
(1)、该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是 run 方法
(2)、也就是说 Thread 类中的 run 方法，用于存储线程要运行的代码
四、线程练习

1、例子

/*
创建两个线程，和主线程交替运行。
*/
class ThreadDemo extends Thread{
    ThreadDemo(String name){
        super(name);
    }
    public void run(){
        for(int x=0;x<60;x++){
            System.out.println(this.getName()+" Thread ："+x);
        }
    }
}
public class Demo{
    public static void main(String[] args){
        ThreadDemo d1 = new ThreadDemo("one");
        ThreadDemo d2 = new ThreadDemo("two");
        d1.start();
        d2.start();
        for(int x=0;x<60;x++){
            System.out.println("main Thread："+x);
        }
    }
}

五、线程运行状态

1、
六、获取线程对象以及名称
1、线程都有自己默认的名称：Thread-编号，该编号从0开始
2、currentThread()：返回对当前正在执行的线程对象的引用。
3、getName()：获取线程名称
4、setName() 或者构造函数：设置线程的名称
七、售票的例子

/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket extends Thread{
    private static int tick = 100;
    public void run(){
        while(true){
            if(tick>0){
                System.out.println(Thread.currentThread().getName()+" sale："+tick--);
            }
        }
    }
}
public class Demo{
    public static void main(String[] args){
        Ticket t1 = new Ticket();
        Ticket t2 = new Ticket();
        Ticket t3 = new Ticket();
        Ticket t4 = new Ticket();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

八、创建线程-实现Runnable接口

1、创建线程的第二种方式：实现 Runable 接口
(1)、定义类实现 Runnable接口
(2)、覆盖 Runnable 接口中的 run 方法,将线程要运行的代码存放在该 run 方法中
(3)、通过 Thread 类建立线程对象
(4)、将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造函数
[1]、为什么要将 Runnable 接口的子类对象传递给 Thread 的构造函数，因为自定义的 run 方法所属的对象是 Runnable 接口的子类对象，所以要让线程去指定对象的 run 方法

(5)、调用 Thread 类的 start 方法开启线程并调用 Runnable 接口子类的 run 方法

/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
    private int tick = 100;
    public void run(){
        while(true){
            if(tick>0){
                System.out.println(Thread.currentThread().getName()+" sale："+tick--);
            }
        }
    }
}
public class Demo{
    public static void main(String[] args){
        Ticket t = new Ticket();
        Thread t0 = new Thread(t);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

2、实现方式和继承方式有什么区别

(1)、实现方式好处：避免了单继承的局限性
(2)、在定义线程时：建议使用实现方式
(3)、两种方式区别：
[1]、继承 Thread：线程代码存放在 Thread 子类 run 方法中
[2]、实现 Runnable：线程代码存放在接口的子类的 run 方法中
九、多线程的安全问题
1、对多条操作共享数据的语句，只能让一个线程都执行完，再执行过程中，不可以参与执行。
2、java对于多线程的安全，提供了专业解决方式：
(1)、就是同步代码块
(2)、synchronized(){}

3、

/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
    private int tick = 10000;
    Object obj = new Object();
    public void run(){
        while(true){
            synchronized(obj){
                if(tick>0){
                    System.out.println(Thread.currentThread().getName()+" sale："+tick--);
                }
            }
        }
    }
}
public class Demo{
    public static void main(String[] args){
        Ticket t = new Ticket();
        Thread t0 = new Thread(t);
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        t0.start();
        t1.start();
        t2.start();
        t3.start();
    }
}

十、多线程同步代码块

1、对象如同锁，持有所得线程可以在同步中执行。
2、没有持有锁的线程即使获取 cpu 的执行权，也进不去，因为没有获取锁
3、火车上的卫生间----经典
4、同步的前提
(1)、必须要有两个或者两个以上的线程
(2)、必须是多个线程使用同一个锁
(3)、必须保证同步过程中必须有一个线程在运行
5、弊端
(1)、多个线程需要判断锁，较为消耗资源
十一、多线程-同步函数

1、synchronized 作为修饰符号，放在函数上

/*
需求：银行有一个金库
有两个储户分别存300元，每次存100，存3次
目的：改程序，是否有安全问题


如何找问题：
    1、明确哪些代码是多线程运行代码
    2、明确共享数据
    3、明确多线程运行代码中哪些语句是操作共享数据的
*/
class Bank{
    private int sum;
    Object obj = new Object();
    public synchronized void add(int n){
        sum = sum + n;
        System.out.println("sunm = "+sum);
    }
}
class Cus implements Runnable{
    private Bank b = new Bank();
    public void run(){
        for(int x=0;x<3;x++){
            b.add(100);
        }
    }
}
public class Demo{
    public static void main(String[] args){
        Cus c = new Cus();
        Thread c0 = new Thread(c);
        Thread c1 = new Thread(c);
        c0.start();
        c1.start();
    }
}

十二、多线程-同步函数的锁是this

1、同步函数用的是哪一个锁呢？
2、函数需要被对象调用。那么函数都有一个所属对象引用。就是this
3、所以同步函数使用的所是this
十三、多线程-静态同步函数的锁是Class对象
1、如果同步函数被静态修饰后，使用的锁是什么呢？
2、通过验证，发现不再是 this ，因为静态方法中也不可以定义 this
3、静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象，
4、类名.class 该对象的类型是Class
5、静态的同步方法，使用的锁是该方法所在类的字节码文件对象类名.class
十四、多线程-单例设计模式-懒汉式
1、对象延迟加载

2、多线程会有问题，使用同步锁，该类所在对象

 public static Single getInstance(){
        if(s==null){
            synchronized(Single.class){
                if(s==null){
                    s = new Single();
                }
            }
        }
        return s;
    }

十五、多线程-死锁

1、同步中嵌套同步

/*
需求：简单的卖票程序
多个窗口卖票
*/
class Ticket implements Runnable{
    private static int tick = 1000;
    Object obj = new Object();
    static boolean flag = true;
    public void run(){
        if(flag){
            while(true){
                synchronized(obj){
                    show();
                }
            }
        }else{
            while(true){
                show();
            }
        }
    }
    public static synchronized void show(){
    flag = true;
        synchronized(obj){
            if(tick>0){
                        try{Thread.sleep(10);}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+" show："+tick--);
            }
        }
    }
}
public class Demo{
    public static void main(String[] args){
        Ticket t = new Ticket();
        Thread t0 = new Thread(t);
        Thread t1 = new Thread(t);
        t0.start();
        try{Thread.sleep(10);}catch(Exception e){}
        t.flag = false;
        t1.start();
    }
}

若云_bai

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础11：线程；synchronized；延迟加载（懒汉模式）；死锁

一、多线程概述 1、进程：是一个正在执行中的程序。 (1)、每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。 2、线程：就是进程中的一个独立的控制单元 (1)、线程控制着进程的执行。 (2)、一个进程中，至少有一个线程 3、Java VM 启动的时候会有一个进程 java.exe
复制链接

扫一扫